home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 February / EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso / earcd / program / esyrxv30.lha / EasyRexx / Includes / Oberon / txt / EasyRexx.mod
Text File  |  1995-11-15  |  9KB  |  273 lines
  1. (*------------------------------------------
  2.  
  3.   :Module.      EasyRexx.mod
  4.   :Author.      Volker Stolz  [vs]
  5.   :Address.     Kückstr. 54 , D-52499 Baesweiler
  6.   :EMail.       Vok@TinDrum.tng.oche.de
  7.   :Phone.       +49 2401 53164
  8.   :Fax.         +49 2401 88869
  9.   :Date.        03-Nov-1995
  10.   :Copyright.   Volker Stolz, 1995
  11.   :Copyright.   It may be distributed freely as long as it remains unchanged.
  12.  
  13.   :Language.    Oberon-2
  14.   :Translator.  Oberon 3.11 05-Dec-93
  15.   :Contents.    Interface to Ketil Hunn`s easyrexx.library
  16.  
  17.   :Remarks.     Please report any bugs & suggestions to
  18.   :Remarks.     <Vok@TinDrum.tng.oche.de> (Volker Stolz) or to
  19.   :Remarks.     <Ketil.Hunn@hiMolde.no> (Ketil Hunn).
  20.  
  21.   :Remarks.     I had to change the name of the ARexxCommandShell-function
  22.   :Remarks.     to OpenARexxCommandShell because of naming-conflicts.
  23.  
  24.   :Remarks.     Remember to check "base # NIL" and library-version !
  25.   :Remarks.     Private data is not exported.
  26.  
  27.   :History.     .0     [vs] 03-Nov-1995 : Created
  28.  
  29. --------------------------------------------*)
  30. MODULE EasyRexx;
  31.  
  32. IMPORT
  33.   Dos,
  34.   E   : Exec,
  35.   I   : Intuition,
  36.   G   : Graphics,
  37.   U   : Utility,
  38.   sys : SYSTEM,
  39.   R   : Rexx;
  40.  
  41. CONST
  42.   easyRexxName    *= "easyrexx.library";
  43.   easyRexxVersion *= 3;
  44.  
  45. TYPE
  46.   ARexxCommandTable *= STRUCT
  47.                          id          *: LONGINT;
  48.                          command*,
  49.                          cmdTemplate *: E.STRPTR;
  50.                          userData    *: E.APTR;
  51.                        END;
  52.  
  53. (* This one is for accesing the CommandTable easily: *)
  54.   ARexxCommandArrayPtr *= UNTRACED POINTER TO ARRAY MAX(INTEGER)-1 OF ARexxCommandTable;
  55.  
  56.   ARexxCommandShell *= STRUCT
  57.                          commandWindow : I.WindowPtr;
  58.                          readPort,
  59.                          writePort     : E.MsgPortPtr;
  60.                          readReq,
  61.                          writeReq      : E.IOStdReqPtr;
  62.                          prompt        : E.LSTRPTR;
  63.                          buffer        : ARRAY 256 OF CHAR;
  64.                          iBuf,inBuffer : E.UBYTE;
  65.                          cursor        : E.BYTE;
  66.                          font          : G.TextFontPtr;
  67.                        END;
  68.   ARexxCommandShellPtr *= UNTRACED POINTER TO ARexxCommandShell;
  69.  
  70.   ARexxContext *= STRUCT
  71.                     port    -: E.MsgPortPtr;
  72.                     table   -: ARexxCommandArrayPtr;
  73.                     argCopy,
  74.                     portName-: E.STRPTR;
  75.                     maxArgs  : E.UBYTE;
  76.                     rdArgs   : Dos.RDArgsPtr;
  77.                     msg      : R.RexxMsgPtr;
  78.                     flags    : E.ULONG;
  79.                     id      -: LONGINT;
  80.                     argv     : UNTRACED POINTER TO ARRAY MAX(INTEGER)-1 OF LONGINT;
  81.                     queue    : E.ULONG;
  82.                     author,
  83.                     copyright,
  84.                     version,
  85.                     lastError: E.STRPTR;
  86.                     reservedCommands : ARexxCommandArrayPtr;
  87.                     shell    : ARexxCommandShellPtr;
  88.                     signals  : LONGSET;
  89.                     result1,
  90.                     result2  : E.APTR;
  91.                     asynchPort : E.MsgPortPtr;
  92.                   END;
  93.  
  94. ARexxContextPtr *= UNTRACED POINTER TO ARexxContext;
  95.  
  96. ARexxMacroData *= STRUCT
  97.                     list *: E.ListPtr;
  98.                   END;
  99. ARexxMacro *= UNTRACED POINTER TO ARexxMacroData;
  100.  
  101. CONST
  102.   TagBase      *= U.user;
  103.   PortName     *= TagBase+1;
  104.   CommandTable *= TagBase+2;
  105.   ReturnCode   *= TagBase+3;
  106.   Result       *= ReturnCode;
  107.   Result1      *= ReturnCode;
  108.   Result2      *= TagBase+4;
  109.   Port         *= TagBase+5;
  110.   ResultString *= TagBase+6;
  111.   ResultLong   *= TagBase+7;
  112.  
  113. (* EasyRexx V2 Tags *)
  114.  
  115.   Asynch       *= TagBase+8;
  116.   Context      *= TagBase+9;
  117.   Author       *= TagBase+10;
  118.   Copyright    *= TagBase+11;
  119.   Version      *= TagBase+12;
  120.   Prompt       *= TagBase+13;
  121.   Close        *= TagBase+14;
  122.   ErrorMessage *= TagBase+15;
  123.   Flags        *= TagBase+16;
  124.   Font         *= TagBase+17;
  125.  
  126. (* EasyREXX V3 Tags *)
  127.  
  128.   Macro        *= TagBase+18;
  129.   MacroFile    *= TagBase+19;
  130.   Record       *= TagBase+20;
  131.   File         *= TagBase+21;
  132.   String       *= TagBase+22;
  133.   Command      *= TagBase+23;
  134.   Arguments    *= TagBase+24;
  135.   Argument     *= Arguments;
  136.   ArgumentsLength *= TagBase+25;
  137.   ArgumentLength  *= ArgumentsLength;
  138.  
  139. TYPE
  140.   RecordPointerType *= ARRAY 38 OF E.WORD;
  141.  
  142. (* Sorry, not ported yet !*)
  143.  
  144. VAR
  145.   base -: E.LibraryPtr;
  146.  
  147. PROCEDURE FreeARexxContext* {base,-78} (context{8} : ARexxContextPtr);
  148. PROCEDURE AllocARexxContextA* {base,-84} (tagList{8} : ARRAY OF U.TagItem) : ARexxContextPtr;
  149. PROCEDURE AllocARexxContext*  {base,-84} (tag1{8}.. : U.Tag) : ARexxContextPtr;
  150. PROCEDURE GetARexxMsg* {base,-90} (context{8} : ARexxContextPtr) : BOOLEAN;
  151. PROCEDURE SendARexxCommandA* {base,-96} (command{9} : E.STRPTR; tagList{8} : ARRAY OF U.TagItem) : LONGINT;
  152. PROCEDURE SendARexxCommand* {base,-96} (command{9} : E.STRPTR; tag1{8}.. : U.Tag) : LONGINT;
  153. PROCEDURE ReplyARexxMsgA* {base,-102} (context{9} : ARexxContextPtr; tagList{8} : ARRAY OF U.TagItem);
  154. PROCEDURE ReplyARexxMsg* {base,-102} (context{9} : ARexxContextPtr; tag1{8}.. : U.Tag);
  155.  
  156. (* Prototypes V2.0 *)
  157. PROCEDURE OpenARexxCommandShellA* {base,-108} (context{9} : ARexxContextPtr; tagList{8} : ARRAY OF U.TagItem) : BOOLEAN;
  158. PROCEDURE OpenARexxCommandShell* {base,-108} (context{9} : ARexxContextPtr; tag1{8}.. : U.Tag) : BOOLEAN;
  159.  
  160. (* Prototypes V3.0 *)
  161. PROCEDURE AllocARexxMacroA* {base,-114} (tagList{8} : ARRAY OF U.TagItem) : ARexxMacro;
  162. PROCEDURE AllocARexxMacro* {base,-114} (tag1{8}.. : U.Tag) : ARexxMacro;
  163. PROCEDURE IsARexxMacroEmpty* {base,-120} (macro{8} : ARexxMacro) : BOOLEAN;
  164. PROCEDURE ClearARexxMacro* {base,-126} (macro{8} : ARexxMacro);
  165. PROCEDURE FreeARexxMacro* {base,-132} (macro{8} : ARexxMacro);
  166. PROCEDURE AddARexxMacroCommandA* {base,-138} (macro{9} : ARexxMacro; tagList{8} : ARRAY OF U.TagItem);
  167. PROCEDURE AddARexxMacroCommand* {base,-138} (macro{9} : ARexxMacro; tag1{8}.. : U.Tag);
  168. PROCEDURE WriteARexxMacroA* {base,-144} (context{8} : ARexxContextPtr; macro{10} : ARexxMacro; macroName{11} : E.UBYTE; tagList{8} : ARRAY OF U.TagItem) : E.BYTE;
  169. PROCEDURE WriteARexxMacro* {base,-144} (context{8} : ARexxContextPtr; macro{10} : ARexxMacro; macroName{11} : E.UBYTE; tagList{8}.. : U.Tag) : E.BYTE;
  170. PROCEDURE RunARexxMacroA* {base,-150} (context{9} : ARexxContextPtr; tagList{8} : ARRAY OF U.TagItem) : E.UBYTE;
  171. PROCEDURE RunARexxMacro* {base,-150} (context{9} : ARexxContextPtr; tag1{8}.. : U.Tag) : E.UBYTE;
  172. PROCEDURE CreateARexxStemA* {base,-156} (context{9} : ARexxContextPtr; stemName{10} : E.UBYTE; vars{8} : ARRAY OF E.STRPTR ) : E.BYTE;
  173. PROCEDURE CreateARexxStem* {base,-156} (context{9} : ARexxContextPtr; stemName{10} : E.UBYTE; vars{8}.. : E.STRPTR) : E.BYTE;
  174.  
  175. (* C-Macro-like Functions [vs] *)
  176.  
  177. PROCEDURE SafeToQuit*(c : ARexxContextPtr) : BOOLEAN;
  178. BEGIN
  179.   RETURN c.queue = 0;
  180. END SafeToQuit;
  181.  
  182. PROCEDURE Arg*(c : ARexxContextPtr; i : INTEGER) : LONGINT;
  183. BEGIN
  184.   RETURN c.argv^[i];
  185. END Arg;
  186.  
  187. PROCEDURE ArgNumber*(c : ARexxContextPtr; i : INTEGER) : LONGINT;
  188. BEGIN
  189.   RETURN c.argv^[i];
  190. END ArgNumber;
  191.  
  192. PROCEDURE ArgString*(c : ARexxContextPtr; i : INTEGER) : E.STRPTR;
  193. BEGIN
  194.   RETURN sys.VAL(E.STRPTR,c.argv^[i]);
  195. END ArgString;
  196.  
  197. PROCEDURE ArgBool*(c : ARexxContextPtr; i : INTEGER) : BOOLEAN;
  198. BEGIN
  199.   RETURN c.argv^[i] # NIL;
  200. END ArgBool;
  201.  
  202. (* Signals *)
  203.  
  204. PROCEDURE ShellSignals* (c : ARexxContextPtr) : LONGSET;
  205. BEGIN
  206.   IF c.shell # NIL THEN
  207.     RETURN LONGSET{c.shell.readPort.sigBit,c.shell.commandWindow.userPort.sigBit};
  208.   ELSE
  209.     RETURN LONGSET{};
  210.   END;
  211. END ShellSignals;
  212.  
  213. PROCEDURE SignalDummy* (c : ARexxContextPtr) : LONGSET;
  214. BEGIN
  215.   RETURN LONGSET{c.port.sigBit,c.asynchPort.sigBit}+ShellSignals(c);
  216. END SignalDummy;
  217.  
  218. PROCEDURE Signal*(c : ARexxContextPtr) : LONGSET;
  219. BEGIN
  220.   IF c # NIL THEN
  221.     RETURN SignalDummy(c);
  222.   ELSE
  223.     RETURN LONGSET{};
  224.   END;
  225. END Signal;
  226.  
  227. PROCEDURE SetSignals*(c : ARexxContextPtr; s : LONGSET);
  228. BEGIN
  229.   c.signals:=s;
  230. END SetSignals;
  231.  
  232. (* Results *)
  233.  
  234. PROCEDURE GetRC*(c : ARexxContextPtr) : E.APTR;
  235. BEGIN
  236.   IF c # NIL THEN
  237.     RETURN c.result1;
  238.   ELSE
  239.     RETURN NIL;
  240.   END;
  241. END GetRC;
  242.  
  243. PROCEDURE GetResult1*(c : ARexxContextPtr) : E.APTR;
  244. BEGIN
  245.   RETURN GetRC(c);
  246. END GetResult1;
  247.  
  248. PROCEDURE GetResult2*(c : ARexxContextPtr) : E.APTR;
  249. BEGIN
  250.   IF c # NIL THEN
  251.     RETURN c.result2;
  252.   ELSE
  253.     RETURN NIL;
  254.   END;
  255. END GetResult2;
  256.  
  257. (* Misc *)
  258.  
  259. PROCEDURE IsShellOpen*(c : ARexxContextPtr) : BOOLEAN;
  260. BEGIN
  261.   RETURN (c.shell # NIL);
  262. END IsShellOpen;
  263.  
  264. (* $OvflChk- $RangeChk- $StackChk- $NilChk- $ReturnChk- $CaseChk- *)
  265.  
  266. (* Remember : YOU are to check "base # NIL" and library-version !!! *)
  267.  
  268. BEGIN
  269.   base:=E.OpenLibrary(easyRexxName,0);
  270. CLOSE
  271.   IF base # NIL THEN E.CloseLibrary(base); END;
  272. END EasyRexx.
  273.